home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / Libraries / WASTE 1.3a5 / WASTE Pascal Interfaces / WASTE.p < prev    next >
Encoding:
Text File  |  1997-07-27  |  28.9 KB  |  968 lines  |  [TEXT/CWIE]
  1. UNIT WASTE;
  2.  
  3. { Pascal interface to the WASTE text engine }
  4.  
  5. { version 1.3a5 (July 1997) }
  6.  
  7. { Copyright © 1993-1997 Marco Piovanelli }
  8. { All Rights Reserved }
  9.  
  10. INTERFACE
  11.     USES
  12.         ConditionalMacros,
  13.         Types,
  14.         MixedMode,
  15.         QuickdrawText,
  16.         Quickdraw,
  17.         Script,
  18.         TextUtils,
  19.         TextEdit,
  20.         Drag,
  21.         LongCoords;
  22.  
  23. {$PUSH}
  24. {$ALIGN MAC68K}
  25. {$LibExport+}
  26.  
  27.     CONST
  28.  
  29. { result codes }
  30.  
  31.         weCantUndoErr = -10015;                    { undo buffer is clear (= errAECantUndo) }
  32.         weEmptySelectionErr = -10013;            { empty selection range (= errAENoUserSelection) }
  33.         weNotHandledErr = -1708;                { please use default behavior (= errAEEventNotHandled) }
  34.         weUnknownObjectTypeErr = -9478;            { specified object type is not registered }
  35.         weObjectNotFoundErr = -9477;            { no object found at specified offset }
  36.         weReadOnlyErr = -9476;                    { cannot modify instance }
  37.         weUndefinedSelectorErr = -50;            { unknown selector (= paramErr) }
  38.  
  39. { alignment styles }
  40.  
  41.         weFlushLeft = -2;                    { flush left }
  42.         weFlushRight = -1;                    { flush right }
  43.         weFlushDefault = 0;                    { flush according to system direction }
  44.         weCenter = 1;                        { centered }
  45.         weJustify = 2;                        { fully justified }
  46.  
  47. { primary line direction }
  48.  
  49.         weDirDefault = 1;                    { according to system direction }
  50.         weDirRightToLeft = -1;                { force right-to-left }
  51.         weDirLeftToRight = 0;                { force left-to-right }
  52.  
  53. { values for the mode parameter in WESetStyle and WEContinuousStyle }
  54.  
  55.         weDoFont                     = $0001;    { set font family number }
  56.         weDoFace                     = $0002;    { set Quickdraw styles }
  57.         weDoSize                     = $0004;    { set type size }
  58.         weDoColor                     = $0008;    { set color }
  59.         weDoAll                     = weDoFont + weDoFace + weDoSize + weDoColor;
  60.         weDoAddSize                 = $0010;    { adjust type size }
  61.         weDoToggleFace                 = $0020;    { turn a style off if it's continuous over the selection }
  62.         weDoReplaceFace             = $0040;    { replace existing styles outright }
  63.         weDoPreserveScript            = $0080;    { don't change scripts when applying a font change }
  64.         weDoExtractSubscript         = $0100;    { extract subscripts when applying a font change }
  65.         weDoFaceMask                 = $0200;    { set Quickdraw styles using mask field }
  66.  
  67. { values for the edge parameter in WEGetOffset etc. }
  68.  
  69.         kLeadingEdge = -1;            { point is on the leading edge of a glyph }
  70.         kTrailingEdge = 0;            { point is on the trailing edge of a glyph }
  71.         kObjectEdge = 2;            { point is in the middle of an embedded object }
  72.  
  73. { values for WEFeatureFlag feature parameter }
  74.  
  75.         weFAutoScroll                 = 0;            { automatically scroll the selection range into view }
  76.         weFOutlineHilite             = 2;            { frame selection when deactivated }
  77.         weFReadOnly                 = 5;            { disallow modifications }
  78.         weFUndo                     = 6;            { support WEUndo }
  79.         weFIntCutAndPaste             = 7;            { use intelligent cut-and-paste rules }
  80.         weFDragAndDrop                 = 8;            { support drag-and-drop text editing }
  81.         weFInhibitRecal             = 9;            { don't recalculate line starts and don't redraw text }
  82.         weFUseTempMem                 = 10;            { use temporary memory for main data structures }
  83.         weFDrawOffscreen             = 11;            { draw text offscreen for smoother visual results }
  84.         weFInhibitRedraw             = 12;            { don't redraw text }
  85.         weFMonoStyled                = 13;            { disallow style changes }
  86.         weFInhibitColor             = 31;            { draw in black & white only }
  87.  
  88. { values for WENew flags parameter }
  89.  
  90.         weDoAutoScroll                 = $00000001;
  91.         weDoOutlineHilite             = $00000004;
  92.         weDoReadOnly                 = $00000020;
  93.         weDoUndo                     = $00000040;
  94.         weDoIntCutAndPaste             = $00000080;
  95.         weDoDragAndDrop             = $00000100;
  96.         weDoInhibitRecal             = $00000200;
  97.         weDoUseTempMem                 = $00000400;
  98.         weDoDrawOffscreen             = $00000800;
  99.         weDoInhibitRedraw            = $00001000;
  100.         weDoMonoStyled                = $00002000;
  101.         weDoInhibitColor            = $80000000;
  102.  
  103. { values for WEFeatureFlag action parameter }
  104.  
  105.         weBitToggle = -2;        { toggles the specified feature }
  106.         weBitTest = -1;            { returns the current setting of the specified feature }
  107.         weBitClear = 0;            { disables the specified feature }
  108.         weBitSet = 1;            { enables the specified feature }
  109.  
  110. { values for WEGetInfo and WESetInfo selector parameter }
  111.  
  112.         weCharByteHook             = 'cbyt';    { CharByte hook }
  113.         weCharToPixelHook         = 'c2p ';    { CharToPixel hook }
  114.         weCharTypeHook             = 'ctyp';    { CharType hook }
  115.         weClickLoop             = 'clik';    { click loop callback }
  116.         weCurrentDrag             = 'drag';    { drag currently being tracked from WEClick }
  117.         weDrawTextHook             = 'draw';    { text drawing hook }
  118.         weEraseHook                = 'eras';    { background erasing hook }
  119.         weFluxProc                = 'flux';    { flux callback }
  120.         weHiliteDropAreaHook     = 'hidr';    { drop area highlighting hook }
  121.         weLineBreakHook         = 'lbrk';    { line breaking hook }
  122.         wePixelToCharHook         = 'p2c ';    { PixelToChar hook }
  123.         wePort                     = 'port';    { graphics port }
  124.         weRefCon                 = 'refc';    { reference constant for use by application }
  125.         weScrollProc             = 'scrl';    { scroll callback }
  126.         weText                     = 'text';    { handle to the raw text }
  127.         weTranslateDragHook     = 'xdrg';    { drag translation callback }
  128.         weTranslucencyThreshold    = 'tluc';    { area threshold for translucent drags }
  129.         weTSMDocumentID         = 'tsmd';    { Text Services Manager document ID }
  130.         weTSMPreUpdate             = 'pre ';    { Text Services Manager pre-update callback }
  131.         weTSMPostUpdate         = 'post';    { Text Services Manager post-update callback }
  132.         weURLHint                 = 'urlh';    { URL hint string for Internet Config }
  133.         weWordBreakHook         = 'wbrk';    { word breaking hook }
  134.  
  135. { values for WEInstallObjectHandler handlerSelector parameter }
  136.  
  137.         weNewHandler             = 'new ';    { new handler }
  138.         weDisposeHandler         = 'free';    { dispose handler }
  139.         weDrawHandler             = 'draw';    { draw handler }
  140.         weClickHandler             = 'clik';    { click handler }
  141.         weStreamHandler         = 'strm';    { stream handler }
  142.  
  143. { action kinds }
  144.  
  145.         weAKNone             = 0;    { null action }
  146.         weAKUnspecified     = 1;    { action of unspecified nature }
  147.         weAKTyping             = 2;    { some text has been typed in }
  148.         weAKCut             = 3;    { the selection range has been cut }
  149.         weAKPaste             = 4;    { something has been pasted }
  150.         weAKClear             = 5;    { the selection range has been deleted }
  151.         weAKDrag             = 6;    { drag and drop operation }
  152.         weAKSetStyle         = 7;    { some style has been applied to a text range }
  153.  
  154. { destination kinds for stream handler }
  155.  
  156.         weToScrap        =    0;
  157.         weToDrag        =    1;
  158.         weToSoup        =    2;
  159.  
  160.     TYPE
  161.  
  162. { WASTE data types }
  163.  
  164.         WEReference = Ptr;
  165.         WEObjectReference = Ptr;
  166.         WESoupHandle = Handle;
  167.         WEFontTableHandle = Handle;
  168.         WEActionKind = INTEGER;
  169.         WEAlignment = SignedByte;
  170.         WEDirection = INTEGER;
  171.         WEStyleMode = INTEGER;
  172.         WESelector = FourCharCode;
  173.         WEHandle = WEReference;        { obsolete; kept for backward compatibility }
  174.  
  175.         WERunInfo = RECORD
  176.                 runStart: LONGINT;                { byte offset to first character of style run }
  177.                 runEnd: LONGINT;                { byte offset past last character of style run }
  178.                 runHeight: INTEGER;                { line height (ascent + descent + leading) }
  179.                 runAscent: INTEGER;                { font ascent }
  180.                 runStyle: TextStyle;            { text attributes }
  181.                 runObject: WEObjectReference;    { either NIL or reference to embedded object }
  182.             END;  { WERunInfo }
  183.  
  184. { callback prototypes }
  185.  
  186. { FUNCTION MyClickLoop (we: WEReference): BOOLEAN; }
  187.         WEClickLoopProcPtr = ProcPtr;
  188.         WEClickLoopUPP = UniversalProcPtr;
  189.  
  190. { PROCEDURE MyScrollProc (we: WEReference); }
  191.         WEScrollProcPtr = ProcPtr;
  192.         WEScrollUPP = UniversalProcPtr;
  193.  
  194. { PROCEDURE MyTSMPreUpdate (we: WEReference); }
  195.         WETSMPreUpdateProcPtr = ProcPtr;
  196.         WETSMPreUpdateUPP = UniversalProcPtr;
  197.  
  198. { PROCEDURE MyTSMPostUpdate (we: WEReference; fixLength: LONGINT; }
  199. {         inputAreaStart, inputAreaEnd: LONGINT; }
  200. {        pinRangeStart, pinRangeEnd: LONGINT); }
  201.         WETSMPostUpdateProcPtr = ProcPtr;
  202.         WETSMPostUpdateUPP = UniversalProcPtr;
  203.  
  204. { FUNCTION MyTranslateDrag (theDrag: DragReference; theItem: ItemReference; }
  205. {         requestedType: FlavorType; putDataHere: Handle; }
  206. {        dropOffset: LONGINT; we: WEReference): OSErr; }
  207.         WETranslateDragProcPtr = ProcPtr;
  208.         WETranslateDragUPP = UniversalProcPtr;
  209.  
  210. { FUNCTION MyHiliteDropArea (theDrag: DragReference; hiliteFlag: BOOLEAN; }
  211. {        we: WEReference): OSErr; }
  212.         WEHiliteDropAreaProcPtr = ProcPtr;
  213.         WEHiliteDropAreaUPP = UniversalProcPtr;
  214.  
  215. { FUNCTION MyFontIDToName (fontID: INTEGER; VAR fontName: Str255): OSErr; }
  216.         WEFontIDToNameProcPtr = ProcPtr;
  217.         WEFontIDToNameUPP = UniversalProcPtr;
  218.  
  219. { FUNCTION MyFontNameToID (fontName: Str255; oldFontID: INTEGER; }
  220. {        VAR newFontID: INTEGER): OSErr; }
  221.         WEFontNameToIDProcPtr = ProcPtr;
  222.         WEFontNameToIDUPP = UniversalProcPtr;
  223.  
  224. { PROCEDURE MyDrawText (pText: Ptr; textLength: LONGINT; slop: Fixed; }
  225. {         styleRunPosition: JustStyleCode; we: WEReference); }
  226.         WEDrawTextProcPtr = ProcPtr;
  227.         WEDrawTextUPP = UniversalProcPtr;
  228.  
  229. { FUNCTION MyPixelToChar (pText: Ptr; textLength: LONGINT; slop: Fixed; }
  230. {         VAR pixelWidth: Fixed; VAR edge: SignedByte; }
  231. {         styleRunPosition: JustStyleCode; hPos: Fixed; we: WEReference): LONGINT; }
  232.         WEPixelToCharProcPtr = ProcPtr;
  233.         WEPixelToCharUPP = UniversalProcPtr;
  234.  
  235. { FUNCTION MyCharToPixel (pText: Ptr; textLength: LONGINT; slop: Fixed; }
  236. {        offset: LONGINT; direction: INTEGER; }
  237. {        styleRunPosition: JustStyleCode; hPos: INTEGER; we:WEReference): INTEGER; }
  238.         WECharToPixelProcPtr = ProcPtr;
  239.         WECharToPixelUPP = UniversalProcPtr;
  240.  
  241. { FUNCTION MyLineBreak (pText: Ptr; textLength: LONGINT; }
  242. {        textStart, textEnd: LONGINT; VAR textWidth: Fixed; VAR textOffset: LONGINT; }
  243. {        we: WEReference): StyledLineBreakCode; }
  244.         WELineBreakProcPtr = ProcPtr;
  245.         WELineBreakUPP = UniversalProcPtr;
  246.  
  247. { PROCEDURE MyWordBreak (pText: Ptr; textLength, offset: INTEGER; edge: SignedByte; }
  248. {                    VAR breakOffsets: OffsetTable; script: ScriptCode; we: WEReference); }
  249.         WEWordBreakProcPtr = ProcPtr;
  250.         WEWordBreakUPP = UniversalProcPtr;
  251.  
  252. { FUNCTION MyCharByte (pText: Ptr; textOffset: INTEGER; }
  253. {                     script: ScriptCode; we: WEReference): INTEGER; }
  254.         WECharByteProcPtr = ProcPtr;
  255.         WECharByteUPP = UniversalProcPtr;
  256.  
  257. { FUNCTION MyCharType (pText: Ptr; textOffset: INTEGER; }
  258. {                     script: ScriptCode; we: WEReference): INTEGER; }
  259.         WECharTypeProcPtr = ProcPtr;
  260.         WECharTypeUPP = UniversalProcPtr;
  261.  
  262. { PROCEDURE MyErase (VAR area: Rect; we: WEReference); }
  263.         WEEraseProcPtr = ProcPtr;
  264.         WEEraseUPP = UniversalProcPtr;
  265.  
  266. { PROCEDURE MyFlux (offset: LONGINT; delta: LONGINT; we: WEReference); }
  267.         WEFluxProcPtr = ProcPtr;
  268.         WEFluxUPP = UniversalProcPtr;
  269.  
  270. { FUNCTION MyNewObject (VAR defaultObjectSize: Point; }
  271. {                    objectRef: WEObjectReference): OSErr; }
  272.         WENewObjectProcPtr = ProcPtr;
  273.         WENewObjectUPP = UniversalProcPtr;
  274.  
  275. { FUNCTION MyDisposeObject (objectRef: WEObjectReference): OSErr; }
  276.         WEDisposeObjectProcPtr = ProcPtr;
  277.         WEDisposeObjectUPP = UniversalProcPtr;
  278.  
  279. { FUNCTION MyDrawObject (VAR destRect: Rect; }
  280. {         objectRef: WEObjectReference): OSErr }
  281.         WEDrawObjectProcPtr = ProcPtr;
  282.         WEDrawObjectUPP = UniversalProcPtr;
  283.  
  284. { FUNCTION MyClickObject (hitPt: Point; modifiers: EventModifiers; clickTime: LONGINT; }
  285. {         objectRef: WEObjectReference): BOOLEAN; }
  286.         WEClickObjectProcPtr = ProcPtr;
  287.         WEClickObjectUPP = UniversalProcPtr;
  288.  
  289. { FUNCTION MyStreamObject (destKind: INTEGER; VAR theType: FlavorType; }
  290. {        putDataHere: Handle; objectRef: WEObjectReference): OSErr; }
  291.         WEStreamObjectProcPtr = ProcPtr;
  292.         WEStreamObjectUPP = UniversalProcPtr;
  293.  
  294.     CONST
  295.  
  296. { UPP proc info }
  297.  
  298.         uppWEClickLoopProcInfo             = $000000D0;
  299.         uppWEScrollProcInfo             = $000000C0;
  300.         uppWETSMPreUpdateProcInfo         = $000000C0;
  301.         uppWETSMPostUpdateProcInfo         = $0003FFC0;
  302.         uppWETranslateDragProcInfo         = $0003FFE0;
  303.         uppWEHiliteDropAreaProcInfo     = $00000DE0;
  304.         uppWEFontIDToNameProcInfo        = $000003A0;
  305.         uppWEFontNameToIDProcInfo        = $00000EE0;
  306.         uppWEDrawTextProcInfo             = $0000EFC0;
  307.         uppWEPixelToCharProcInfo         = $003EFFF0;
  308.         uppWECharToPixelProcInfo         = $003ABFE0;
  309.         uppWELineBreakProcInfo             = $000FFFD0;
  310.         uppWEWordBreakProcInfo             = $000EDAC0;
  311.         uppWECharByteProcInfo             = $00003AE0;
  312.         uppWECharTypeProcInfo             = $00003AE0;
  313.         uppWEEraseProcInfo                = $000003C0;
  314.         uppWEFluxProcInfo                = $00000FC0;
  315.         uppWENewObjectProcInfo             = $000003E0;
  316.         uppWEDisposeObjectProcInfo         = $000000E0;
  317.         uppWEDrawObjectProcInfo         = $000003E0;
  318.         uppWEClickObjectProcInfo         = $00003ED0;
  319.         uppWEStreamObjectProcInfo         = $00003FA0;
  320.  
  321. { NewProc macros }
  322.  
  323.     FUNCTION NewWEClickLoopProc (userRoutine: WEClickLoopProcPtr): WEClickLoopUPP;
  324. {$IFC NOT GENERATINGCFM}
  325.     INLINE
  326.         $2E9F;
  327. {$ENDC}
  328.  
  329.     FUNCTION NewWEScrollProc (userRoutine: WEScrollProcPtr): WEScrollUPP;
  330. {$IFC NOT GENERATINGCFM}
  331.     INLINE
  332.         $2E9F;
  333. {$ENDC}
  334.  
  335.     FUNCTION NewWETSMPreUpdateProc (userRoutine: WETSMPreUpdateProcPtr): WETSMPreUpdateUPP;
  336. {$IFC NOT GENERATINGCFM}
  337.     INLINE
  338.         $2E9F;
  339. {$ENDC}
  340.  
  341.     FUNCTION NewWETSMPostUpdateProc (userRoutine: WETSMPostUpdateProcPtr): WETSMPostUpdateUPP;
  342. {$IFC NOT GENERATINGCFM}
  343.     INLINE
  344.         $2E9F;
  345. {$ENDC}
  346.  
  347.     FUNCTION NewWETranslateDragProc (userRoutine: WETranslateDragProcPtr): WETranslateDragUPP;
  348. {$IFC NOT GENERATINGCFM}
  349.     INLINE
  350.         $2E9F;
  351. {$ENDC}
  352.  
  353.     FUNCTION NewWEHiliteDropAreaProc (userRoutine: WEHiliteDropAreaProcPtr): WEHiliteDropAreaUPP;
  354. {$IFC NOT GENERATINGCFM}
  355.     INLINE
  356.         $2E9F;
  357. {$ENDC}
  358.  
  359.     FUNCTION NewWEFontIDToNameProc (userRoutine: WEFontIDToNameProcPtr): WEFontIDToNameUPP;
  360. {$IFC NOT GENERATINGCFM}
  361.     INLINE
  362.         $2E9F;
  363. {$ENDC}
  364.  
  365.     FUNCTION NewWEFontNameToIDProc (userRoutine: WEFontNameToIDProcPtr): WEFontNameToIDUPP;
  366. {$IFC NOT GENERATINGCFM}
  367.     INLINE
  368.         $2E9F;
  369. {$ENDC}
  370.  
  371.     FUNCTION NewWEDrawTextProc (userRoutine: WEDrawTextProcPtr): WEDrawTextUPP;
  372. {$IFC NOT GENERATINGCFM}
  373.     INLINE
  374.         $2E9F;
  375. {$ENDC}
  376.  
  377.     FUNCTION NewWEPixelToCharProc (userRoutine: WEPixelToCharProcPtr): WEPixelToCharUPP;
  378. {$IFC NOT GENERATINGCFM}
  379.     INLINE
  380.         $2E9F;
  381. {$ENDC}
  382.  
  383.     FUNCTION NewWECharToPixelProc (userRoutine: WECharToPixelProcPtr): WECharToPixelUPP;
  384. {$IFC NOT GENERATINGCFM}
  385.     INLINE
  386.         $2E9F;
  387. {$ENDC}
  388.  
  389.     FUNCTION NewWELineBreakProc (userRoutine: WELineBreakProcPtr): WELineBreakUPP;
  390. {$IFC NOT GENERATINGCFM}
  391.     INLINE
  392.         $2E9F;
  393. {$ENDC}
  394.  
  395.     FUNCTION NewWEWordBreakProc (userRoutine: WEWordBreakProcPtr): WEWordBreakUPP;
  396. {$IFC NOT GENERATINGCFM}
  397.     INLINE
  398.         $2E9F;
  399. {$ENDC}
  400.  
  401.     FUNCTION NewWECharByteProc (userRoutine: WECharByteProcPtr): WECharByteUPP;
  402. {$IFC NOT GENERATINGCFM}
  403.     INLINE
  404.         $2E9F;
  405. {$ENDC}
  406.  
  407.     FUNCTION NewWECharTypeProc (userRoutine: WECharTypeProcPtr): WECharTypeUPP;
  408. {$IFC NOT GENERATINGCFM}
  409.     INLINE
  410.         $2E9F;
  411. {$ENDC}
  412.  
  413.     FUNCTION NewWEEraseProc (userRoutine: WEEraseProcPtr): WEEraseUPP;
  414. {$IFC NOT GENERATINGCFM}
  415.     INLINE
  416.         $2E9F;
  417. {$ENDC}
  418.  
  419.     FUNCTION NewWEFluxProc (userRoutine: WEFluxProcPtr): WEFluxUPP;
  420. {$IFC NOT GENERATINGCFM}
  421.     INLINE
  422.         $2E9F;
  423. {$ENDC}
  424.  
  425.     FUNCTION NewWENewObjectProc (userRoutine: WENewObjectProcPtr): WENewObjectUPP;
  426. {$IFC NOT GENERATINGCFM}
  427.     INLINE
  428.         $2E9F;
  429. {$ENDC}
  430.  
  431.     FUNCTION NewWEDisposeObjectProc (userRoutine: WEDisposeObjectProcPtr): WEDisposeObjectUPP;
  432. {$IFC NOT GENERATINGCFM}
  433.     INLINE
  434.         $2E9F;
  435. {$ENDC}
  436.  
  437.     FUNCTION NewWEDrawObjectProc (userRoutine: WEDrawObjectProcPtr): WEDrawObjectUPP;
  438. {$IFC NOT GENERATINGCFM}
  439.     INLINE
  440.         $2E9F;
  441. {$ENDC}
  442.  
  443.     FUNCTION NewWEClickObjectProc (userRoutine: WEClickObjectProcPtr): WEClickObjectUPP;
  444. {$IFC NOT GENERATINGCFM}
  445.     INLINE
  446.         $2E9F;
  447. {$ENDC}
  448.  
  449.     FUNCTION NewWEStreamObjectProc (userRoutine: WEStreamObjectProcPtr): WEStreamObjectUPP;
  450. {$IFC NOT GENERATINGCFM}
  451.     INLINE
  452.         $2E9F;
  453. {$ENDC}
  454.  
  455. { CallProc macros }
  456.  
  457.     FUNCTION CallWEClickLoopProc (we: WEReference;
  458.                                     userRoutine: WEClickLoopUPP): BOOLEAN;
  459. {$IFC NOT GENERATINGCFM}
  460.     INLINE
  461.         $205F, $4E90;
  462. {$ENDC}
  463.  
  464.     PROCEDURE CallWEScrollProc (we: WEReference;
  465.                                     userRoutine: WEScrollUPP);
  466. {$IFC NOT GENERATINGCFM}
  467.     INLINE
  468.         $205F, $4E90;
  469. {$ENDC}
  470.  
  471.     PROCEDURE CallWETSMPreUpdateProc (we: WEReference;
  472.                                     userRoutine: WETSMPreUpdateUPP);
  473. {$IFC NOT GENERATINGCFM}
  474.     INLINE
  475.         $205F, $4E90;
  476. {$ENDC}
  477.  
  478.     PROCEDURE CallWETSMPostUpdateProc (we: WEReference;
  479.                                     fixLength: LONGINT;
  480.                                     inputAreaStart, inputAreaEnd: LONGINT;
  481.                                     pinRangeStart, pinRangeEnd: LONGINT;
  482.                                     userRoutine: WETSMPostUpdateUPP);
  483. {$IFC NOT GENERATINGCFM}
  484.     INLINE
  485.         $205F, $4E90;
  486. {$ENDC}
  487.  
  488.     FUNCTION CallWETranslateDragProc (theDrag: DragReference;
  489.                                     theItem: ItemReference;
  490.                                     requestedType: FlavorType;
  491.                                     putDataHere: Handle;
  492.                                     dropOffset: LONGINT;
  493.                                     we: WEReference;
  494.                                     userRoutine: WETranslateDragUPP): OSErr;
  495. {$IFC NOT GENERATINGCFM}
  496.     INLINE
  497.         $205F, $4E90;
  498. {$ENDC}
  499.  
  500.     FUNCTION CallWEHiliteDropAreaProc (theDrag: DragReference;
  501.                                     hiliteFlag: BOOLEAN;
  502.                                     we: WEReference;
  503.                                     userRoutine: WEHiliteDropAreaUPP): OSErr;
  504. {$IFC NOT GENERATINGCFM}
  505.     INLINE
  506.         $205F, $4E90;
  507. {$ENDC}
  508.  
  509.     FUNCTION CallWEFontIDToNameProc (fontID: INTEGER;
  510.                                     VAR fontName: Str255;
  511.                                     userRoutine: WEFontIDToNameUPP): OSErr;
  512. {$IFC NOT GENERATINGCFM}
  513.     INLINE
  514.         $205F, $4E90;
  515. {$ENDC}
  516.  
  517.     FUNCTION CallWEFontNameToIDProc ({CONST} VAR fontName: Str255;
  518.                                     oldFontID: INTEGER;
  519.                                     VAR newFontID: INTEGER;
  520.                                     userRoutine: WEFontNameToIDUPP): OSErr;
  521. {$IFC NOT GENERATINGCFM}
  522.     INLINE
  523.         $205F, $4E90;
  524. {$ENDC}
  525.  
  526.     PROCEDURE CallWEDrawTextProc (pText: Ptr;
  527.                                     textLength: LONGINT;
  528.                                     slop: Fixed;
  529.                                     styleRunPosition: JustStyleCode;
  530.                                     we: WEReference;
  531.                                     userRoutine: WEDrawTextUPP);
  532. {$IFC NOT GENERATINGCFM}
  533.     INLINE
  534.         $205F, $4E90;
  535. {$ENDC}
  536.  
  537.     FUNCTION CallWEPixelToCharProc (pText: Ptr;
  538.                                     textLength: LONGINT;
  539.                                     slop: Fixed;
  540.                                     VAR width: Fixed;
  541.                                     VAR edge: SignedByte;
  542.                                     styleRunPosition: JustStyleCode;
  543.                                     hPos: Fixed;
  544.                                     we: WEReference;
  545.                                     userRoutine: WEPixelToCharUPP): LONGINT;
  546. {$IFC NOT GENERATINGCFM}
  547.     INLINE
  548.         $205F, $4E90;
  549. {$ENDC}
  550.  
  551.     FUNCTION CallWECharToPixelProc (pText: Ptr;
  552.                                     textLength: LONGINT;
  553.                                     slop: Fixed;
  554.                                     offset: LONGINT;
  555.                                     direction: INTEGER;
  556.                                     styleRunPosition: JustStyleCode;
  557.                                     hPos: INTEGER;
  558.                                     we: WEReference;
  559.                                     userRoutine: WECharToPixelUPP): INTEGER;
  560. {$IFC NOT GENERATINGCFM}
  561.     INLINE
  562.         $205F, $4E90;
  563. {$ENDC}
  564.  
  565.     FUNCTION CallWELineBreakProc (pText: Ptr;
  566.                                     textLength: LONGINT;
  567.                                     textStart, textEnd: LONGINT;
  568.                                     VAR textWidth: Fixed;
  569.                                     VAR textOffset: LONGINT;
  570.                                     we: WEReference;
  571.                                     userRoutine: WELineBreakUPP): StyledLineBreakCode;
  572. {$IFC NOT GENERATINGCFM}
  573.     INLINE
  574.         $205F, $4E90;
  575. {$ENDC}
  576.  
  577.     PROCEDURE CallWEWordBreakProc (pText: Ptr;
  578.                                     textLength, offset: INTEGER;
  579.                                     edge: SignedByte;
  580.                                     VAR breakOffsets: OffsetTable;
  581.                                     script: ScriptCode;
  582.                                     we: WEReference;
  583.                                     userRoutine: WEWordBreakUPP);
  584. {$IFC NOT GENERATINGCFM}
  585.     INLINE
  586.         $205F, $4E90;
  587. {$ENDC}
  588.  
  589.     FUNCTION CallWECharByteProc (pText: Ptr;
  590.                                     textOffset: INTEGER;
  591.                                     script: ScriptCode;
  592.                                     we: WEReference;
  593.                                     userRoutine: WECharByteUPP): INTEGER;
  594. {$IFC NOT GENERATINGCFM}
  595.     INLINE
  596.         $205F, $4E90;
  597. {$ENDC}
  598.  
  599.     FUNCTION CallWECharTypeProc (pText: Ptr;
  600.                                     textOffset: INTEGER;
  601.                                     script: ScriptCode;
  602.                                     we: WEReference;
  603.                                     userRoutine: WECharTypeUPP): INTEGER;
  604. {$IFC NOT GENERATINGCFM}
  605.     INLINE
  606.         $205F, $4E90;
  607. {$ENDC}
  608.  
  609.     PROCEDURE CallWEEraseProc ({CONST} VAR area: Rect;
  610.                                     we: WEReference;
  611.                                     userRoutine: WEEraseUPP);
  612. {$IFC NOT GENERATINGCFM}
  613.     INLINE
  614.         $205F, $4E90;
  615. {$ENDC}
  616.  
  617.     PROCEDURE CallWEFluxProc (offset: LONGINT;
  618.                                     delta: LONGINT;
  619.                                     we: WEReference;
  620.                                     userRoutine: WEFluxUPP);
  621. {$IFC NOT GENERATINGCFM}
  622.     INLINE
  623.         $205F, $4E90;
  624. {$ENDC}
  625.  
  626.     FUNCTION CallWENewObjectProc (VAR defaultObjectSize: Point;
  627.                                     objectRef: WEObjectReference;
  628.                                     userRoutine: WENewObjectUPP): OSErr;
  629. {$IFC NOT GENERATINGCFM}
  630.     INLINE
  631.         $205F, $4E90;
  632. {$ENDC}
  633.  
  634.     FUNCTION CallWEDisposeObjectProc (objectRef: WEObjectReference;
  635.                                     userRoutine: WEDisposeObjectUPP): OSErr;
  636. {$IFC NOT GENERATINGCFM}
  637.     INLINE
  638.         $205F, $4E90;
  639. {$ENDC}
  640.  
  641.     FUNCTION CallWEDrawObjectProc ({CONST} VAR destRect: Rect;
  642.                                     objectRef: WEObjectReference;
  643.                                     userRoutine: WEDrawObjectUPP): OSErr;
  644. {$IFC NOT GENERATINGCFM}
  645.     INLINE
  646.         $205F, $4E90;
  647. {$ENDC}
  648.  
  649.     FUNCTION CallWEClickObjectProc (hitPoint: Point;
  650.                                     modifiers: EventModifiers;
  651.                                     clickTime: LONGINT;
  652.                                     objectRef: WEObjectReference;
  653.                                     userRoutine: WEClickObjectUPP): BOOLEAN;
  654. {$IFC NOT GENERATINGCFM}
  655.     INLINE
  656.         $205F, $4E90;
  657. {$ENDC}
  658.  
  659.     FUNCTION CallWEStreamObjectProc (destKind: INTEGER;
  660.                                     VAR theType: FlavorType;
  661.                                     putDataHere: Handle;
  662.                                     objectRef: WEObjectReference;
  663.                                     userRoutine: WEStreamObjectUPP): OSErr;
  664. {$IFC NOT GENERATINGCFM}
  665.     INLINE
  666.         $205F, $4E90;
  667. {$ENDC}
  668.  
  669.  
  670. { WASTE PUBLIC CALLS }
  671.  
  672. { getting the shared library version number }
  673.  
  674.     FUNCTION WEVersion: NumVersion;
  675.  
  676. { creation and destruction }
  677.  
  678.     FUNCTION WENew ({CONST} VAR destRect, viewRect: LongRect;
  679.                                     flags: LONGINT;
  680.                                     VAR we: WEReference): OSErr;
  681.     PROCEDURE WEDispose (we: WEReference);
  682.  
  683. { getting variables }
  684.  
  685.     FUNCTION WEGetText (we: WEReference): Handle;
  686.     FUNCTION WEGetChar (offset: LONGINT;
  687.                                     we: WEReference): CHAR;
  688.     FUNCTION WEGetTextLength (we: WEReference): LONGINT;
  689.     FUNCTION WEGetHeight (startLine, endLine: LONGINT;
  690.                                     we: WEReference): LONGINT;
  691.     PROCEDURE WEGetSelection (VAR selStart, selEnd: LONGINT;
  692.                                     we: WEReference);
  693.     PROCEDURE WEGetDestRect (VAR destRect: LongRect;
  694.                                     we: WEReference);
  695.     PROCEDURE WEGetViewRect (VAR viewRect: LongRect;
  696.                                     we: WEReference);
  697.     FUNCTION WEIsActive (we: WEReference): BOOLEAN;
  698.     FUNCTION WEOffsetToLine (offset: LONGINT;
  699.                                     we: WEReference): LONGINT;
  700.     PROCEDURE WEGetLineRange (lineNo: LONGINT;
  701.                                     VAR lineStart, lineEnd: LONGINT;
  702.                                     we: WEReference);
  703.     FUNCTION WECountLines (we: WEReference): LONGINT;
  704.     FUNCTION WEOffsetToRun (offset: LONGINT;
  705.                                     we: WEReference): LONGINT;
  706.     PROCEDURE WEGetRunRange (runIndex: LONGINT;
  707.                                     VAR runStart, runEnd: LONGINT;
  708.                                     we: WEReference);
  709.     FUNCTION WECountRuns (we: WEReference): LONGINT;
  710.     FUNCTION WEGetClickCount (we: WEReference): INTEGER;
  711.  
  712. { setting variables }
  713.  
  714.     PROCEDURE WESetSelection (selStart, selEnd: LONGINT;
  715.                                     we: WEReference);
  716.     PROCEDURE WESetDestRect ({CONST} VAR destRect: LongRect;
  717.                                     we: WEReference);
  718.     PROCEDURE WESetViewRect ({CONST} VAR viewRect: LongRect;
  719.                                     we: WEReference);
  720.  
  721. { accessing style run information }
  722.  
  723.     FUNCTION WEContinuousStyle (VAR mode: WEStyleMode;
  724.                                     VAR ts: TextStyle;
  725.                                     we: WEReference): BOOLEAN;
  726.     PROCEDURE WEGetRunInfo (offset: LONGINT;
  727.                                     VAR info: WERunInfo;
  728.                                     we: WEReference);
  729.     FUNCTION WEGetRunDirection (offset: LONGINT;
  730.                                     we: WEReference): BOOLEAN;
  731.  
  732. { converting byte offsets to screen positions and vice versa }
  733.  
  734.     FUNCTION WEGetOffset ({CONST} VAR thePoint: LongPt;
  735.                                     VAR edge: SignedByte;
  736.                                     we: WEReference): LONGINT;
  737.     PROCEDURE WEGetPoint (offset: LONGINT;
  738.                                     direction: INTEGER;
  739.                                     VAR thePoint: LongPt;
  740.                                     VAR lineHeight: INTEGER;
  741.                                     we: WEReference);
  742.  
  743. { finding words, lines and paragraphs }
  744.  
  745.     PROCEDURE WEFindWord (offset: LONGINT;
  746.                                     edge: SignedByte;
  747.                                     VAR wordStart, wordEnd: LONGINT;
  748.                                     we: WEReference);
  749.     PROCEDURE WEFindLine (offset: LONGINT;
  750.                                     edge: SignedByte;
  751.                                     VAR lineStart, lineEnd: LONGINT;
  752.                                     we: WEReference);
  753.     PROCEDURE WEFindParagraph (offset: LONGINT;
  754.                                     edge: SignedByte;
  755.                                     VAR paragraphStart, paragraphEnd: LONGINT;
  756.                                     we: WEReference);
  757.  
  758. { making a copy of a text range }
  759.  
  760.     FUNCTION WECopyRange (rangeStart, rangeEnd: LONGINT;
  761.                                     hText: Handle;
  762.                                     hStyles: StScrpHandle;
  763.                                     hSoup: WESoupHandle;
  764.                                     we: WEReference): OSErr;
  765.  
  766. { getting and setting the alignment style }
  767.  
  768.     FUNCTION WEGetAlignment (we: WEReference): WEAlignment;
  769.     PROCEDURE WESetAlignment (alignment: WEAlignment;
  770.                                     we: WEReference);
  771.  
  772. { getting and setting the primary line direction }
  773.  
  774.     FUNCTION WEGetDirection (we: WEReference): WEDirection;
  775.     PROCEDURE WESetDirection (direction: WEDirection;
  776.                                     we: WEReference);
  777.  
  778. { recalculating line breaks, drawing and scrolling }
  779.  
  780.     FUNCTION WECalText (we: WEReference): OSErr;
  781.     PROCEDURE WEUpdate (updateRgn: RgnHandle;
  782.                                     we: WEReference);
  783.     PROCEDURE WEScroll (hOffset, vOffset: LONGINT;
  784.                                     we: WEReference);
  785.     PROCEDURE WESelView (we: WEReference);
  786.  
  787. { handling activate/deactivate events }
  788.  
  789.     PROCEDURE WEActivate (we: WEReference);
  790.     PROCEDURE WEDeactivate (we: WEReference);
  791.  
  792. { handling key-down events }
  793.  
  794.     PROCEDURE WEKey (key: CHAR;
  795.                                     modifiers: EventModifiers;
  796.                                     we: WEReference);
  797.  
  798. { handling mouse-down events and mouse tracking }
  799.  
  800.     PROCEDURE WEClick (hitPt: Point;
  801.                                     modifiers: EventModifiers;
  802.                                     clickTime: LONGINT;
  803.                                     we: WEReference);
  804.  
  805. { adjusting the cursor shape }
  806.  
  807.     FUNCTION WEAdjustCursor (mouseLoc: Point;
  808.                                     mouseRgn: RgnHandle;
  809.                                     we: WEReference): BOOLEAN;
  810.  
  811. { blinking the caret }
  812.  
  813.     PROCEDURE WEIdle (VAR maxSleep: LONGINT;
  814.                                     we: WEReference);
  815.  
  816. { modifying the text and the styles }
  817.  
  818.     FUNCTION WEInsert (pText: Ptr;
  819.                                     textLength: LONGINT;
  820.                                     hStyles: StScrpHandle;
  821.                                     hSoup: WESoupHandle;
  822.                                     we: WEReference): OSErr;
  823.     FUNCTION WEDelete (we: WEReference): OSErr;
  824.     FUNCTION WESetStyle (mode: WEStyleMode;
  825.                                     {CONST} VAR ts: TextStyle;
  826.                                     we: WEReference): OSErr;
  827.     FUNCTION WEUseText (hText: Handle;
  828.                                     we: WEReference): OSErr;
  829.     FUNCTION WEUseStyleScrap (hStyles: StScrpHandle;
  830.                                     we: WEReference): OSErr;
  831.  
  832. { undo }
  833.  
  834.     FUNCTION WEUndo (we: WEReference): OSErr;
  835.     PROCEDURE WEClearUndo (we: WEReference);
  836.     FUNCTION WEGetUndoInfo (VAR redoFlag: BOOLEAN;
  837.                                     we: WEReference): WEActionKind;
  838.     FUNCTION WEIsTyping (we: WEReference): BOOLEAN;
  839.     FUNCTION WEBeginAction (we: WEReference): OSErr;
  840.     FUNCTION WEEndAction (actionKind: WEActionKind;
  841.                                     we: WEReference): OSErr;
  842.  
  843. { keeping track of changes }
  844.  
  845.     FUNCTION WEGetModCount (we: WEReference): LONGINT;
  846.     PROCEDURE WEResetModCount (we: WEReference);
  847.  
  848. { embedded objects }
  849.  
  850.     FUNCTION WEInstallObjectHandler (objectType: FlavorType;
  851.                                     handlerSelector: WESelector;
  852.                                     handler: ProcPtr;
  853.                                     we: WEReference): OSErr;
  854.     FUNCTION WEGetObjectHandler (objectType: FlavorType;
  855.                                     handlerSelector: WESelector;
  856.                                     VAR handler: ProcPtr;
  857.                                     we: WEReference): OSErr;
  858.     FUNCTION WEInsertObject (objectType: FlavorType;
  859.                                     objectDataHandle: Handle;
  860.                                     objectSize: Point;        { (0, 0) means default size }
  861.                                     we: WEReference): OSErr;
  862.     FUNCTION WEGetSelectedObject (VAR objectRef: WEObjectReference;
  863.                                     we: WEReference): OSErr;
  864.     FUNCTION WEFindNextObject (offset: LONGINT;
  865.                                     VAR objectRef: WEObjectReference;
  866.                                     we: WEReference): LONGINT;
  867.     FUNCTION WEUseSoup (hSoup: WESoupHandle;
  868.                                     we: WEReference): OSErr;
  869.  
  870. { accessing embedded object attributes }
  871.  
  872.     FUNCTION WEGetObjectType (objectRef: WEObjectReference): FlavorType;
  873.     FUNCTION WEGetObjectDataHandle (objectRef: WEObjectReference): Handle;
  874.     FUNCTION WEGetObjectSize (objectRef: WEObjectReference): Point;
  875.     FUNCTION WEGetObjectOwner (objectRef: WEObjectReference): WEReference;
  876.     FUNCTION WEGetObjectRefCon (objectRef: WEObjectReference): LONGINT;
  877.     PROCEDURE WESetObjectRefCon (objectRef: WEObjectReference;
  878.                                     refCon: LONGINT);
  879.  
  880. { Clipboard operations }
  881.  
  882.     FUNCTION WECut (we: WEReference): OSErr;
  883.     FUNCTION WECopy (we: WEReference): OSErr;
  884.     FUNCTION WEPaste (we: WEReference): OSErr;
  885.     FUNCTION WECanPaste (we: WEReference): BOOLEAN;
  886.  
  887. { Drag Manager support }
  888.  
  889.     FUNCTION WEGetHiliteRgn (rangeStart, rangeEnd: LONGINT;
  890.                                     we: WEReference): RgnHandle;
  891.     FUNCTION WETrackDrag (message: DragTrackingMessage;
  892.                                     drag: DragReference;
  893.                                     we: WEReference): OSErr;
  894.     FUNCTION WEReceiveDrag (drag: DragReference;
  895.                                     we: WEReference): OSErr;
  896.     FUNCTION WECanAcceptDrag (drag: DragReference;
  897.                                     we: WEReference): BOOLEAN;
  898.     FUNCTION WEDraggedToTrash (drag: DragReference): BOOLEAN;
  899.  
  900. { font tables }
  901.  
  902.     FUNCTION WEBuildFontTable (hFontTable: WEFontTableHandle;
  903.                                     fontIDToNameProc: WEFontIDToNameUPP;
  904.                                     we: WEReference): OSErr;
  905.     FUNCTION WEUpdateFontTable (hFontTable: WEFontTableHandle;
  906.                                     fontNameToIDProc: WEFontNameToIDUPP;
  907.                                     VAR wasChanged: BOOLEAN): OSErr;
  908.     FUNCTION WEUpdateStyleScrap (hStyles: StScrpHandle;
  909.                                     hFontTable: WEFontTableHandle): OSErr;
  910.  
  911. { Script Manager utilities }
  912.  
  913.     FUNCTION WECharByte (offset: LONGINT;
  914.                                     we: WEReference): INTEGER;
  915.     FUNCTION WECharType (offset: LONGINT;
  916.                                     we: WEReference): INTEGER;
  917.  
  918. { Text Services Manager support }
  919.  
  920.     FUNCTION WEInstallTSMHandlers: OSErr;
  921.     FUNCTION WERemoveTSMHandlers: OSErr;
  922.     FUNCTION WEHandleTSMEvent ({CONST} VAR ae: AppleEvent;
  923.                                     VAR reply: AppleEvent): OSErr;
  924.     PROCEDURE WEStopInlineSession (we: WEReference);
  925.  
  926. { additional features }
  927.  
  928.     FUNCTION WEFeatureFlag (feature: INTEGER;
  929.                                     action: INTEGER;
  930.                                     we: WEReference): INTEGER;
  931.     FUNCTION WEGetInfo (selector: WESelector;
  932.                                     info: univ Ptr;
  933.                                     we: WEReference): OSErr;
  934.     FUNCTION WESetInfo (selector: WESelector;
  935.                                     info: univ Ptr;
  936.                                     we: WEReference): OSErr;
  937.  
  938. { getting and setting user-defined info }
  939.  
  940.     FUNCTION WEGetUserInfo (tag: WESelector;
  941.                                     VAR userInfo: LONGINT;
  942.                                     we: WEReference): OSErr;
  943.     FUNCTION WESetUserInfo (tag: WESelector;
  944.                                     userInfo: LONGINT;
  945.                                     we: WEReference): OSErr;
  946.  
  947. { long coordinates utility routines }
  948.  
  949.     PROCEDURE WELongPointToPoint ({CONST} VAR lp: LongPt;
  950.                                     VAR p: Point);
  951.     PROCEDURE WEPointToLongPoint (p: Point;
  952.                                     VAR lp: LongPt);
  953.     PROCEDURE WESetLongRect (VAR lr: LongRect;
  954.                                     left, top, right, bottom: LONGINT);
  955.     PROCEDURE WELongRectToRect ({CONST} VAR lr: LongRect;
  956.                                     VAR r: Rect);
  957.     PROCEDURE WERectToLongRect ({CONST} VAR r: Rect;
  958.                                     VAR lr: LongRect);
  959.     PROCEDURE WEOffsetLongRect (VAR lr: LongRect;
  960.                                     hOffset, vOffset: LONGINT);
  961.     FUNCTION WELongPointInLongRect ({CONST} VAR lp: LongPt;
  962.                                     {CONST} VAR lr: LongRect): BOOLEAN;
  963.  
  964. {$ALIGN RESET}
  965. {$POP}
  966.  
  967. IMPLEMENTATION
  968. END.